package com.shuai.AI.ai_app.chatmemory;

import com.shuai.AI.ai_app.utils.RedisUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.chat.memory.ChatMemory;
import org.springframework.ai.chat.messages.Message;

/** 基于Redis的聊天记录存储实现 - 使用 FastJson2 */
@Slf4j
public class RedisBasedChatMemory implements ChatMemory {

  private final RedisUtils redisUtils;
  private final int maxMessages;

  private RedisBasedChatMemory(RedisUtils redisUtils, int maxMessages) {
    this.redisUtils = redisUtils;
    this.maxMessages = maxMessages;
  }

  /** 创建 Builder */
  public static Builder builder(RedisUtils redisUtils) {
    return new Builder(redisUtils);
  }

  /** Builder 类 */
  public static class Builder {
    private final RedisUtils redisUtils;
    private int maxMessages = 20;

    public Builder(RedisUtils redisUtils) {
      this.redisUtils = redisUtils;
    }

    public Builder maxMessages(int maxMessages) {
      this.maxMessages = maxMessages;
      return this;
    }

    public RedisBasedChatMemory build() {
      return new RedisBasedChatMemory(redisUtils, maxMessages);
    }
  }

  /** 向对话中添加消息（追加而非覆盖） */
  @Override
  public void add(String conversationId, List<Message> messages) {
    if (messages == null || messages.isEmpty()) {
      return;
    }

    // 转换为可序列化的 DTO
    List<SerializableMessage> serializableMessages =
        messages.stream().map(SerializableMessage::fromMessage).collect(Collectors.toList());

    // 使用Redis的列表结构，将新消息追加到末尾
    for (SerializableMessage message : serializableMessages) {
      redisUtils.rPush(conversationId, message);
    }

    // 修剪列表，确保不超过最大消息数
    long size = redisUtils.lSize(conversationId);
    if (size > maxMessages) {
      redisUtils.lTrim(conversationId, size - maxMessages, -1);
    }
  }

  /** 获取对话的所有消息（实现接口方法） */
  @Override
  public List<Message> get(String conversationId) {
    return get(conversationId, maxMessages);
  }

  /** 获取对话的最近N条消息（自定义方法，供内部使用） */
  public List<Message> get(String conversationId, int lastN) {
    if (lastN <= 0) {
      return new ArrayList<>();
    }

    // 获取列表的长度
    long size = redisUtils.lSize(conversationId);
    if (size == 0) {
      return new ArrayList<>();
    }

    // 计算起始位置（从0开始）
    long start = Math.max(0, size - lastN);
    long end = size - 1;

    // 从Redis获取指定范围的消息
    List<Object> objects = redisUtils.lRange(conversationId, start, end);

    // 转换为Message列表
    List<Message> messageList = new ArrayList<>();
    for (Object obj : objects) {
      // 直接判断并强转为SerializableMessage（因为RedisSerializer已自动反序列化）
      if (obj instanceof SerializableMessage) {
        SerializableMessage serializableMessage = (SerializableMessage) obj;
        Message message = serializableMessage.toMessage(serializableMessage.getMessageType());
        messageList.add(message);
        log.info("获取历史对话消息：{}", message.getText()); // 加日志验证
      } else {
        log.warn("Redis中存在非SerializableMessage类型的对象：{}", obj.getClass().getName());
      }
    }
    return messageList;
  }

  /** 清除对话记录 */
  @Override
  public void clear(String conversationId) {
    redisUtils.delete(conversationId);
  }
}
